In [1]:
#codigo de cabecera --> para ello instalamos geopandas en "open terminal"
import os, geopandas as gpd

# país elegido: 
china = gpd.read_file(os.path.join("mapasChina","China_En","China_Pl.shp"))

#polígonos
ciudades = gpd.read_file(os.path.join("mapasChina","China_Cities_Towns","China_Cities_Towns.shp"))
areasUrbanas = gpd.read_file(os.path.join("mapasChina","China_Urban_Areas","China_Urban_Areas.shp"))
cuerposDeAgua = gpd.read_file(os.path.join("mapasChina","China_Water_Bodies","China_Water_Bodies.shp"))

# líneas:
rios = gpd.read_file(os.path.join("mapasChina","China_Hydrography","China_Hydrography.shp"))
ferrocarriles = gpd.read_file(os.path.join("mapasChina","China_Railroads","China_Railroads.shp"))
carreteras = gpd.read_file(os.path.join("mapasChina","China_Roads","China_Roads.shp"))

# para tener en cuenta que estamos haciendo:
# "mapasChina" --> carpeta donde guardamos los archivos .rar y los que descomprimimos
# "China_En" --> nombre de la carpeta descomprimida
# "China_Pl.shp" --> dentro de la carpeta "China_En" está este shapefile
# OJO: la extensión ".shp" es utilizado para almacenar información geográfica y espacial
In [2]:
# verificamos el tipo de dato para la variable "china"
type(china)
Out[2]:
geopandas.geodataframe.GeoDataFrame
In [3]:
# verificamos el tipo de dato para la variable "ciudades"
type(ciudades)
Out[3]:
geopandas.geodataframe.GeoDataFrame
In [4]:
# verificamos el tipo de dato para la variable "areasUrbanas"
type(areasUrbanas)
Out[4]:
geopandas.geodataframe.GeoDataFrame
In [5]:
# verificamos el tipo de dato para la variable "cuerposDeAgua"
type(cuerposDeAgua)
Out[5]:
geopandas.geodataframe.GeoDataFrame
In [6]:
# verificamos el tipo de dato para la variable "rios"
type(rios)
Out[6]:
geopandas.geodataframe.GeoDataFrame
In [7]:
# verificamos el tipo de dato para la variable "ferrocarriles"
type(ferrocarriles)
Out[7]:
geopandas.geodataframe.GeoDataFrame
In [8]:
# verificamos el tipo de dato para la variable "carreteras"
type(carreteras)
Out[8]:
geopandas.geodataframe.GeoDataFrame
In [9]:
# dimensiones de "china"
china.shape

# (28, 2) --> tiene 28 filas y 2 columnas
Out[9]:
(28, 2)
In [10]:
# names
china.columns

# 'Id' --> identificador único para cada registro de la capa de datos geoespaciales
# 'geometry' --> contiene información geográfica y espacial del país "china", como puntos, líneas o polígonos
Out[10]:
Index(['Id', 'geometry'], dtype='object')
In [11]:
# contenido de "china"
china.head()
Out[11]:
Id geometry
0 0 POLYGON ((123.45705 53.50650, 123.46433 53.498...
1 0 POLYGON ((121.45534 39.64558, 121.46991 39.642...
2 0 POLYGON ((121.37493 31.82396, 121.37503 31.788...
3 0 POLYGON ((121.98422 29.11444, 121.98183 29.105...
4 0 POLYGON ((122.12701 29.78348, 122.13143 29.779...
In [12]:
# contenido de "ciudades"
ciudades.head()
Out[12]:
NAME geometry
0 Wusuli POINT (123.27793 53.55233)
1 Mohe POINT (122.34412 53.47615)
2 Shang-lao-kou POINT (122.10260 53.30531)
3 Xikouzi POINT (120.65665 53.13139)
4 Ershiyizhan POINT (124.92904 52.87976)
In [13]:
# contenido de "areasUrbanas"
areasUrbanas.head()
Out[13]:
ID geometry
0 1 POLYGON ((122.35153 53.46278, 122.34337 53.468...
1 2 POLYGON ((123.83556 52.69439, 123.83270 52.702...
2 3 POLYGON ((124.71432 52.32668, 124.69751 52.328...
3 4 POLYGON ((123.66184 52.10870, 123.65645 52.111...
4 5 POLYGON ((124.70179 52.02954, 124.68919 52.029...
In [14]:
# contenido de "cuerposDeAgua"
cuerposDeAgua.head()
Out[14]:
NAME geometry
0 NaN POLYGON ((98.81810 34.47373, 98.75949 34.45359...
1 NaN POLYGON ((102.26344 33.83246, 102.25987 33.831...
2 Shuoguoke Hu POLYGON ((100.63714 42.48615, 100.66170 42.479...
3 Shuobo Hu POLYGON ((101.28431 42.33086, 101.29453 42.327...
4 NaN POLYGON ((128.05568 41.98811, 128.04661 41.988...
In [15]:
# contenido de "rios"
rios.head()
Out[15]:
NAME geometry
0 NaN LINESTRING (91.38573 29.28649, 91.38492 29.284...
1 NaN LINESTRING (124.03345 45.71852, 124.03345 45.7...
2 NaN LINESTRING (100.99610 42.42176, 100.98489 42.4...
3 NaN LINESTRING (101.23776 42.26225, 101.25378 42.2...
4 NaN LINESTRING (128.05348 42.02793, 128.04444 42.0...
In [16]:
# contenido de "ferrocarriles"
ferrocarriles.head()
Out[16]:
TYPE geometry
0 1 LINESTRING (123.56954 53.09262, 123.56764 53.0...
1 1 LINESTRING (123.74986 53.04703, 123.75158 53.0...
2 1 LINESTRING (123.51112 52.98682, 123.51725 53.0...
3 1 LINESTRING (123.51112 52.98682, 123.49099 52.9...
4 1 LINESTRING (123.31249 52.89673, 123.33939 52.8...
In [17]:
# contenido de "carreteras"
carreteras.head()
Out[17]:
TYPE geometry
0 2 LINESTRING (123.35620 53.44056, 123.35687 53.4...
1 2 LINESTRING (123.35620 53.44056, 123.40727 53.4...
2 2 LINESTRING (124.00000 53.31580, 124.00481 53.3...
3 2 LINESTRING (124.64031 52.97569, 124.64873 52.9...
4 8 LINESTRING (123.87680 52.70866, 123.87283 52.7...
In [18]:
# tipo de datos de "china"
china.info()

<class 'geopandas.geodataframe.GeoDataFrame'>
RangeIndex: 28 entries, 0 to 27
Data columns (total 2 columns):
 #   Column    Non-Null Count  Dtype   
---  ------    --------------  -----   
 0   Id        28 non-null     int64   
 1   geometry  28 non-null     geometry
dtypes: geometry(1), int64(1)
memory usage: 576.0 bytes
In [19]:
# tipo de datos de "ciudades"
ciudades.info()

<class 'geopandas.geodataframe.GeoDataFrame'>
RangeIndex: 5015 entries, 0 to 5014
Data columns (total 2 columns):
 #   Column    Non-Null Count  Dtype   
---  ------    --------------  -----   
 0   NAME      5015 non-null   object  
 1   geometry  5015 non-null   geometry
dtypes: geometry(1), object(1)
memory usage: 78.5+ KB
In [20]:
# tipo de datos de "areasUrbanas"
areasUrbanas.info()

<class 'geopandas.geodataframe.GeoDataFrame'>
RangeIndex: 1514 entries, 0 to 1513
Data columns (total 2 columns):
 #   Column    Non-Null Count  Dtype   
---  ------    --------------  -----   
 0   ID        1514 non-null   int64   
 1   geometry  1514 non-null   geometry
dtypes: geometry(1), int64(1)
memory usage: 23.8 KB
In [21]:
# tipo de datos de "cuerposDeAgua"
cuerposDeAgua.info()

<class 'geopandas.geodataframe.GeoDataFrame'>
RangeIndex: 294 entries, 0 to 293
Data columns (total 2 columns):
 #   Column    Non-Null Count  Dtype   
---  ------    --------------  -----   
 0   NAME      205 non-null    object  
 1   geometry  294 non-null    geometry
dtypes: geometry(1), object(1)
memory usage: 4.7+ KB
In [22]:
# tipo de datos de "rios"
rios.info()

<class 'geopandas.geodataframe.GeoDataFrame'>
RangeIndex: 2328 entries, 0 to 2327
Data columns (total 2 columns):
 #   Column    Non-Null Count  Dtype   
---  ------    --------------  -----   
 0   NAME      1714 non-null   object  
 1   geometry  2328 non-null   geometry
dtypes: geometry(1), object(1)
memory usage: 36.5+ KB
In [23]:
# tipo de datos de "ferrocarriles"
ferrocarriles.info()

<class 'geopandas.geodataframe.GeoDataFrame'>
RangeIndex: 5556 entries, 0 to 5555
Data columns (total 2 columns):
 #   Column    Non-Null Count  Dtype   
---  ------    --------------  -----   
 0   TYPE      5556 non-null   int64   
 1   geometry  5556 non-null   geometry
dtypes: geometry(1), int64(1)
memory usage: 86.9 KB
In [24]:
# tipo de datos de "carreteras"
carreteras.info()

<class 'geopandas.geodataframe.GeoDataFrame'>
RangeIndex: 27256 entries, 0 to 27255
Data columns (total 2 columns):
 #   Column    Non-Null Count  Dtype   
---  ------    --------------  -----   
 0   TYPE      27256 non-null  int64   
 1   geometry  27256 non-null  geometry
dtypes: geometry(1), int64(1)
memory usage: 426.0 KB
In [25]:
# "folium" --> biblioteca de Python utilizada para crear mapas interactivos y visualizaciones de datos geoespaciales
import folium
In [26]:
# PRIMER PASO --> TRAZADO DE LOS MAPAS BÁSICO
In [27]:
# creamos una visualización gráfica de los datos contenidos en el marco de datos "china"
china.plot()
Out[27]:
<Axes: >
In [28]:
# creamos una visualización gráfica de los datos contenidos en el marco de datos "ciudades"
ciudades.plot()
Out[28]:
<Axes: >
In [29]:
# creamos una visualización gráfica de los datos contenidos en el marco de datos "areasUrbanas"
areasUrbanas.plot()
Out[29]:
<Axes: >
In [30]:
# creamos una visualización gráfica de los datos contenidos en el marco de datos "cuerposDeAgua"
cuerposDeAgua.plot()
Out[30]:
<Axes: >
In [31]:
# creamos una visualización gráfica de los datos contenidos en el marco de datos "rios"
rios.plot()
Out[31]:
<Axes: >
In [32]:
# creamos una visualización gráfica de los datos contenidos en el marco de datos "ferrocarriles"
ferrocarriles.plot()
Out[32]:
<Axes: >
In [33]:
# creamos una visualización gráfica de los datos contenidos en el marco de datos "carreteras"
carreteras.plot()
Out[33]:
<Axes: >
In [34]:
# SEGUNDO PASO --> AJUSTES VISUALES PARA LOS POLÍGONOS
In [35]:
china.plot(facecolor="azure", # color del relleno del polígono (parte interna)
               edgecolor='black', # color de las líneas
               linewidth=0.1) # grosor de las líneas
Out[35]:
<Axes: >
In [36]:
ciudades.plot(marker='.', # tipo de marcador
            color='red', 
            markersize=1,
            alpha=0.3) # transpariencia
Out[36]:
<Axes: >
In [37]:
areasUrbanas.plot(marker='p', # tipo de marcador
                  color='none', 
                  markersize=10,
                  edgecolor='black',
                  linewidth=3,
                  alpha=1)
Out[37]:
<Axes: >
In [38]:
cuerposDeAgua.plot(marker='x', # tipo de marcador circular
            color='deeppink', 
            markersize=7, # aumentar tamaño del marcador
            alpha=1) # aumentar la transparencia
Out[38]:
<Axes: >
In [39]:
# TERCER PASO --> AJUSTES VISUALES PARA LAS LÍNEAS
In [40]:
rios.plot(edgecolor='blue', 
            linewidth=1,
            linestyle='dotted')
Out[40]:
<Axes: >
In [41]:
ferrocarriles.plot(edgecolor='darkorange', 
            linewidth=1,
            linestyle='dotted')
Out[41]:
<Axes: >
In [42]:
carreteras.plot(edgecolor='lightgreen', 
            linewidth=0.7,
            linestyle='dotted')
Out[42]:
<Axes: >
In [43]:
# verificamos que tengan la misma proyección
# empezamos con "china"
china.crs
Out[43]:
<Geographic 2D CRS: EPSG:4326>
Name: WGS 84
Axis Info [ellipsoidal]:
- Lat[north]: Geodetic latitude (degree)
- Lon[east]: Geodetic longitude (degree)
Area of Use:
- name: World.
- bounds: (-180.0, -90.0, 180.0, 90.0)
Datum: World Geodetic System 1984 ensemble
- Ellipsoid: WGS 84
- Prime Meridian: Greenwich
In [44]:
# seguimos con "ciudades"
ciudades.crs
Out[44]:
<Geographic 2D CRS: EPSG:4326>
Name: WGS 84
Axis Info [ellipsoidal]:
- Lat[north]: Geodetic latitude (degree)
- Lon[east]: Geodetic longitude (degree)
Area of Use:
- name: World.
- bounds: (-180.0, -90.0, 180.0, 90.0)
Datum: World Geodetic System 1984 ensemble
- Ellipsoid: WGS 84
- Prime Meridian: Greenwich
In [45]:
# seguimos con "areasUrbanas"
areasUrbanas.crs
Out[45]:
<Geographic 2D CRS: EPSG:4326>
Name: WGS 84
Axis Info [ellipsoidal]:
- Lat[north]: Geodetic latitude (degree)
- Lon[east]: Geodetic longitude (degree)
Area of Use:
- name: World.
- bounds: (-180.0, -90.0, 180.0, 90.0)
Datum: World Geodetic System 1984 ensemble
- Ellipsoid: WGS 84
- Prime Meridian: Greenwich
In [46]:
# seguimos con "cuerposDeAgua"
cuerposDeAgua.crs
Out[46]:
<Geographic 2D CRS: EPSG:4326>
Name: WGS 84
Axis Info [ellipsoidal]:
- Lat[north]: Geodetic latitude (degree)
- Lon[east]: Geodetic longitude (degree)
Area of Use:
- name: World.
- bounds: (-180.0, -90.0, 180.0, 90.0)
Datum: World Geodetic System 1984 ensemble
- Ellipsoid: WGS 84
- Prime Meridian: Greenwich
In [47]:
# seguimos con "rios"
rios.crs
Out[47]:
<Geographic 2D CRS: EPSG:4326>
Name: WGS 84
Axis Info [ellipsoidal]:
- Lat[north]: Geodetic latitude (degree)
- Lon[east]: Geodetic longitude (degree)
Area of Use:
- name: World.
- bounds: (-180.0, -90.0, 180.0, 90.0)
Datum: World Geodetic System 1984 ensemble
- Ellipsoid: WGS 84
- Prime Meridian: Greenwich
In [48]:
# seguimos con "ferrocarriles"
ferrocarriles.crs
Out[48]:
<Geographic 2D CRS: EPSG:4326>
Name: WGS 84
Axis Info [ellipsoidal]:
- Lat[north]: Geodetic latitude (degree)
- Lon[east]: Geodetic longitude (degree)
Area of Use:
- name: World.
- bounds: (-180.0, -90.0, 180.0, 90.0)
Datum: World Geodetic System 1984 ensemble
- Ellipsoid: WGS 84
- Prime Meridian: Greenwich
In [49]:
# seguimos con "carreteras"
carreteras.crs
Out[49]:
<Geographic 2D CRS: EPSG:4326>
Name: WGS 84
Axis Info [ellipsoidal]:
- Lat[north]: Geodetic latitude (degree)
- Lon[east]: Geodetic longitude (degree)
Area of Use:
- name: World.
- bounds: (-180.0, -90.0, 180.0, 90.0)
Datum: World Geodetic System 1984 ensemble
- Ellipsoid: WGS 84
- Prime Meridian: Greenwich
In [50]:
# como podemos observar manejan la misma salida
In [51]:
# codigo para empezar a suponerponer los mapas

# para los polígonos
ciudades = ciudades.to_crs(china.crs)
areasUrbanas = areasUrbanas.to_crs(china.crs)
cuerposDeAgua = cuerposDeAgua.to_crs(china.crs)

# para las líneas
rios = rios.to_crs(china.crs)
ferrocarriles = ferrocarriles.to_crs(china.crs)
carreteras = carreteras.to_crs(china.crs)
In [52]:
# comenzamos creando la capa en la parte posterior (la base) y agregar capas en la parte superior
# generamos una visualización espacial en la que superponemos tres capas de información geográfica en un mismo gráfico:

# NOTA: el orden de las líneas y polígonos importa ya que si se superponen unos encima de otros, 
# el que esté debajo no se mostrará, por tanto: es necesario asegurarse de que todos los elementos
# se superpongan en el orden correcto

# denominamos a nuestra imagen base como "baseMapa"
baseMapa = china.plot(facecolor="azure", edgecolor='black', linewidth=0.1, figsize=(12,12))

# superponemos el polígono más importante y notorio: las "ciudades"
ciudades.plot(marker='.', color='red', markersize=5, alpha=0.5, ax=baseMapa, zorder=3)

# superponemos las líneas: como en el caso de China son muy abundantes, las superponemos de mayor a menor orden
rios.plot(edgecolor='blue', linewidth=0.5, alpha=0.5, ax=baseMapa, zorder=1)
ferrocarriles.plot(edgecolor='darkorange', linewidth=1, alpha=0.5, ax=baseMapa, label='Ferrocarriles', zorder=2)
carreteras.plot(edgecolor='lightgreen', linewidth=1, alpha=0.5, ax=baseMapa, label='Carreteras', zorder=2)

# superponemos los polígonos de "areasUrbanas" y "cuerposDeAgua" al último para que sean visibles, ya que
# en este caso, son muy pocas las áreas urbanas y cuerpos de agua a comparación de los ríos, ferrocarriles y carreteras
areasUrbanas.plot(marker='p', color='none', markersize=10, edgecolor='black', linewidth=4, alpha=1, ax=baseMapa)
cuerposDeAgua.plot(marker='o', color='deeppink', markersize=5, alpha=1, ax=baseMapa, zorder=1)

# agregamos título y leyenda a nuestro mapa del país asiático: "China"
baseMapa.set_title("Mapa de China", fontsize=20)
Out[52]:
Text(0.5, 1.0, 'Mapa de China')
In [53]:
# como hemos importado "folium", podemos hacer un mapa interacivo, ya que
# una buena característica sería representar el mapa de forma interactiva:

import folium

m = ciudades.explore(color="red", name="ciudades")

m = rios.explore(m=m, color="blue", name="rios")

m = ferrocarriles.explore(m=m, color="darkorange", name="ferrocarriles")

m = carreteras.explore(m=m, color="lightgreen", name="carreteras")

m = areasUrbanas.explore(m=m, color="black", name="areasUrbanas")

m = cuerposDeAgua.explore(m=m, color="deeppink", name="cuerposDeAgua")

# mapa interactivo que permite al usuario activar y desactivar diferentes capas de información en el mapa
folium.LayerControl().add_to(m)
m
Out[53]:
Make this Notebook Trusted to load map: File -> Trust Notebook
In [54]:
# guardamos el mapa no interactivo como imagen (7 archivos SHP):

# módulo de la biblioteca matplotlib que proporciona una forma conveniente de crear gráficos y visualizaciones en Python
import matplotlib.pyplot as plt

baseMapa = china.plot(facecolor="azure", edgecolor='black', linewidth=0.1, figsize=(12,12))

ciudades.plot(marker='.', color='red', markersize=5, alpha=0.5, ax=baseMapa, zorder=3)

rios.plot(edgecolor='blue', linewidth=0.5, alpha=0.5, ax=baseMapa, zorder=1)
ferrocarriles.plot(edgecolor='darkorange', linewidth=1, alpha=0.5, ax=baseMapa, label='Ferrocarriles', zorder=2)
carreteras.plot(edgecolor='lightgreen', linewidth=1, alpha=0.5, ax=baseMapa, label='Carreteras', zorder=2)

areasUrbanas.plot(marker='p', color='none', markersize=10, edgecolor='black', linewidth=4, alpha=1, ax=baseMapa)
cuerposDeAgua.plot(marker='o', color='deeppink', markersize=5, alpha=1, ax=baseMapa, zorder=1)

baseMapa.set_title("Mapa de China", fontsize=20)

plt.savefig(os.path.join("mapasChina",'mapaFinal.jpg'))
In [55]:
# guardamos el mapa no interactivo como imagen (3 archivos SHP):

baseMapa2 = china.plot(facecolor="azure", edgecolor='black', linewidth=0.1, figsize=(12,12))

ciudades.plot(marker='.', color='red', markersize=5, alpha=0.5, ax=baseMapa2, zorder=3)
rios.plot(edgecolor='blue', linewidth=0.5, alpha=0.5, ax=baseMapa2, zorder=1)
areasUrbanas.plot(marker='p', color='none', markersize=10, edgecolor='black', linewidth=4, alpha=1, ax=baseMapa2)

baseMapa2.set_title("Mapa de China", fontsize=20)

plt.savefig(os.path.join("mapasChina",'mapaFinal2.jpg'))
In [56]:
# guardamos los marcos de geodatos en un archivo de geopaquete (mapa con los 6 archivos de SHP)
# no hemos cambiado el mapa inicial, pero podríamos exportar los mapas a un tipo de archivo diferente (no shapefiles)
ciudades.to_file(os.path.join("mapasChina","chinaMapas.gpkg"), layer='ciudades', driver="GPKG")
areasUrbanas.to_file(os.path.join("mapasChina","chinaMapas.gpkg"), layer='areasUrbanas', driver="GPKG")
cuerposDeAgua.to_file(os.path.join("mapasChina","chinaMapas.gpkg"), layer='cuerposDeAgua', driver="GPKG")
rios.to_file(os.path.join("mapasChina","chinaMapas.gpkg"), layer='rios', driver="GPKG")
ferrocarriles.to_file(os.path.join("mapasChina","chinaMapas.gpkg"), layer='ferrocarriles', driver="GPKG")
carreteras.to_file(os.path.join("mapasChina","chinaMapas.gpkg"), layer='carreteras', driver="GPKG")
In [57]:
chinaMapas = 'https://github.com/thiagoDali/EX1/raw/main/mapasChina/chinaMapas.gpkg'
In [58]:
from  fiona import listlayers

listlayers(chinaMapas)
Out[58]:
['ciudades',
 'areasUrbanas',
 'cuerposDeAgua',
 'rios',
 'ferrocarriles',
 'carreteras']
In [59]:
ciudades=gpd.read_file(chinaMapas,layer='ciudades')
areasUrbanas=gpd.read_file(chinaMapas,layer='areasUrbanas')
cuerposDeAgua=gpd.read_file(chinaMapas,layer='cuerposDeAgua')
rios=gpd.read_file(chinaMapas,layer='rios')
ferrocarriles=gpd.read_file(chinaMapas,layer='ferrocarriles')
carreteras=gpd.read_file(chinaMapas,layer='carreteras')
In [ ]: